ResNet34¶
這裡為ResNet34的訓練結果及過程，詳細的結果以及討論會在Pdf報告中與其他Model呈現。¶
Library¶
In [ ]:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import os
import cv2
import glob
import time
#DATA
from keras.preprocessing.sequence import pad_sequences
from keras.preprocessing.text import one_hot
from keras.utils.np_utils import to_categorical
from sklearn.model_selection import train_test_split
#CNN
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
from keras.models import Sequential
from keras.layers import Convolution2D,MaxPooling2D,Flatten,Dense, AveragePooling2D,GlobalAveragePooling2D, Input
from keras.layers import Dense, Activation, Conv2D, MaxPooling2D, Flatten,Dropout, BatchNormalization
from keras.optimizers import Adam
from keras.losses import CategoricalCrossentropy
from keras.layers.merge import concatenate
from keras.models import Model
from mlxtend.plotting import plot_confusion_matrix
from sklearn.metrics import multilabel_confusion_matrix,confusion_matrix
from sklearn.metrics import accuracy_score
from keras.models import Model,load_model
#VIS
from keras.utils.vis_utils import plot_model
from tensorflow.keras.preprocessing import image
from tensorflow.python.keras.models import load_model #Tensorflow 2.0
Data Preprocessing¶
In [ ]:
def Data_process(path):
'''
parameters: path(STR) of the directory and flag(INT) to know if we prepare data of training or testing
return: (LIST) of images of the dataset and the (LIST) of labels
For training:
-Read images of every directory and extract all images
-Resize to (150,150,3)
-Read the directory name and asign as a class
'''
X = []
y = []
for directory in sorted(glob.glob(os.path.join(path, '*')), key = lambda k: k.split("/")[-1]):
for imgs in glob.glob(os.path.join(directory,'*.jpg')):
img_cv = cv2.imread(imgs)
img_cv = cv2.cvtColor(img_cv,cv2.COLOR_BGR2RGB)
img_cv_r = cv2.resize(img_cv,(150,150))
X.append(img_cv_r)
y.append(int(directory.split("/")[-1].replace('c','')))
X_train, X_test, y_train, y_test = train_test_split(X,y, test_size = 0.2)
return np.array(X_train), np.array(X_test) ,np.array(y_train), np.array(y_test)
In [ ]:
#Paths
train_data_path = "/kaggle/input/state-farm-distracted-driver-detection/imgs/train/"
test_data_path = "/kaggle/input/state-farm-distracted-driver-detection/imgs/test/"
#List of Images for Train and Test
X_train, X_test , y_train, y_test= Data_process(train_data_path)
print('X_train shape:',X_train.shape)
print('y_train shape:',y_train.shape)
print('X_test shape:',X_test.shape)
print('y_test shape:',y_test.shape)
In [ ]:
y_train_one = keras.utils.to_categorical(y_train,10)
y_test_one = keras.utils.to_categorical(y_test,10)
print('X_train shape:',X_train.shape)
print('y_train shape:',y_train_one.shape)
print('X_test shape:',X_test.shape)
print('y_test shape:',y_test_one.shape)
Data Observation¶
In [ ]:
print("There are ",np.unique(y_train),"different labels in this dataset.")
print('Labels count in y_train:', np.bincount(y_train))
print('Labels count in y_test:', np.bincount(y_test),'\n')
label = {"mask_name":[],"data":[]}
for i in np.unique(y_train):
label["mask_name"].append("label " + str(i))
label["data"].append(X_train[y_train==i,:])
labels=['safe driving','texting - right','talking on the phone - right'
,'texting - left','talking on the phone - left','operating the radio',
'drinking','reaching behind','hair and makeup','talking to passenger']
print('Showing some examples of different labels\n')
#fig, axes = plt.subplots(2, 5, figsize = (5, 5))
fig = plt.figure(figsize = (20, 20))
for i in np.unique(y_train):
ax = fig.add_subplot(2, 5, i+1)
ax.set_xticks([])
ax.set_yticks([])
ax.imshow(label["data"][i][1])
ax.set_title('Label '+str(i)+' '+str(labels[i]), fontsize = 18)
plt.tight_layout()
Building Model¶
ResNet34¶
In [ ]:
def Conv2d_BN(layer, nb_filter,kernel_size, padding='same',strides=(1,1)):
layer = Conv2D(nb_filter,kernel_size,padding=padding,strides=strides,activation='relu')(layer)
layer = BatchNormalization(axis=3)(layer)
return layer
def Residual_Block(input_model,nb_filter,kernel_size,strides=(1,1), shortcut =False):
layer= Conv2d_BN(input_model,nb_filter=nb_filter,kernel_size=kernel_size,strides=strides,padding='same')
layer= Conv2d_BN(layer, nb_filter=nb_filter, kernel_size=kernel_size,padding='same')
if shortcut:
shortcut = Conv2d_BN(input_model,nb_filter=nb_filter,strides=strides,kernel_size=kernel_size)
layer= layers.add([layer,shortcut])
return layer
else:
layer= layers.add([layer,input_model])
return layer
def ResNet34(width, height, depth, classes):
Img = Input(shape=(width,height,depth))
layer= Conv2d_BN(Img,64,(7,7),strides=(2,2),padding='same')
layer= MaxPooling2D(pool_size=(3,3),strides=(2,2),padding='same')(layer)
layer= Residual_Block(layer,nb_filter=64,kernel_size=(3,3))
layer= Residual_Block(layer,nb_filter=64,kernel_size=(3,3))
layer= Residual_Block(layer,nb_filter=64,kernel_size=(3,3))
layer= Residual_Block(layer,nb_filter=128,kernel_size=(3,3),strides=(2,2),shortcut=True)
layer= Residual_Block(layer,nb_filter=128,kernel_size=(3,3))
layer= Residual_Block(layer,nb_filter=128,kernel_size=(3,3))
layer= Residual_Block(layer,nb_filter=128,kernel_size=(3,3))
layer= Residual_Block(layer,nb_filter=256,kernel_size=(3,3),strides=(2,2),shortcut=True)
layer= Residual_Block(layer,nb_filter=256,kernel_size=(3,3))
layer= Residual_Block(layer,nb_filter=256,kernel_size=(3,3))
layer= Residual_Block(layer,nb_filter=256,kernel_size=(3,3))
layer= Residual_Block(layer,nb_filter=256,kernel_size=(3,3))
layer= Residual_Block(layer,nb_filter=256,kernel_size=(3,3))
layer= Residual_Block(layer,nb_filter=512,kernel_size=(3,3),strides=(2,2),shortcut=True)
layer= Residual_Block(layer,nb_filter=512,kernel_size=(3,3))
layer= Residual_Block(layer,nb_filter=512,kernel_size=(3,3))
layer= GlobalAveragePooling2D()(layer)
layer= Dense(classes,activation='softmax')(layer)
model=Model(inputs=Img,outputs=layer)
return model
In [ ]:
ResNet34_model = ResNet34(150,150,3,10)
ResNet34_model.summary()
plot_model(ResNet34_model, show_shapes=True)
Out[ ]:
Training ResNet34¶
In [ ]:
from keras.callbacks import ModelCheckpoint
#path creation
base_filename='ResNet34_best_weight'
filename_suffix = 'hdf5'
k=1
learning_rate=[0.0001, 0.0005, 0.001]
batch_size=[16, 32, 48]
for i in (learning_rate):
for j in (batch_size):
print("Learning rate：", i ,"& Batch size：", j)
ResNet34_model = ResNet34(150,150,3,10)
ResNet34_model.compile(optimizer=Adam(lr=i, beta_1=0.9, beta_2=0.999, epsilon=1e-08),loss = 'categorical_crossentropy',metrics=['accuracy'])
tStart = time.time()#計時開始
## save best model
number = str(k)
filepath=os.path.join(base_filename + number + "." + filename_suffix)
early_stop = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=3)
checkpoint = ModelCheckpoint(filepath, monitor='val_loss', verbose=1, save_best_only=True, mode='min')
callbacks_list = [checkpoint]
hist_ResNet34=ResNet34_model.fit(X_train,y_train_one,batch_size=j,epochs=10,validation_split=0.2, callbacks=[early_stop, checkpoint], verbose=1)
tEnd = time.time()#計時結束
k+=1
print("Training Time :",tEnd-tStart,"\n")
scores = ResNet34_model.evaluate(X_test,y_test_one,verbose=1)
acc = hist_ResNet34.history['accuracy']
val_acc = hist_ResNet34.history['val_accuracy']
loss = hist_ResNet34.history['loss']
val_loss = hist_ResNet34.history['val_loss']
epochs = range(1, len(acc) + 1)
plt.subplot(1, 2, 1)
plt.plot(epochs, acc, label='Training acc')
plt.plot(epochs, val_acc, label='Validation acc')
plt.title('Training and validation accuracy')
plt.legend()
plt.subplot(1, 2, 2)
plt.plot(epochs, loss, label='Training loss')
plt.plot(epochs, val_loss, label='Validation loss')
plt.title('Training and validation loss')
plt.legend()
plt.tight_layout()
plt.show()
Confusion Matrix¶
In [ ]:
best_model = tf.keras.models.load_model('ResNet34_best_weight4.hdf5')
y_pr=best_model.predict(X_test)
y_pred=[]
for i in range(len(y_pr)):
y_pred.append(np.argmax(y_pr[i]))
cm=confusion_matrix(y_test,y_pred)
ac=accuracy_score(y_test,y_pred)
print("Accuracy", ac)
print("Confusion matrix")
plot_confusion_matrix(cm,figsize=(9,9),colorbar=True)
Out[ ]:
Filter and Feature Observation¶
In [ ]:
img = X_test[0]
plt.imshow(img)
plt.grid(False)
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
In [ ]:
'''
model = Model(inputs=VGG16_model, outputs=outputs)
model.compile(loss='categorical_crossentropy',
optimizer=Adam(),
metrics=['accuracy'])
'''
layer_outputs = [layer.output for layer in ResNet34_model.layers if not layer.name.startswith('input')]
activation_model = Model(inputs=ResNet34_model.input, outputs=layer_outputs)
activations = activation_model.predict(x)
#first_conv_activation = activations[1]
def plot_activations(layer_idx, activations):
layer_activation = activations[layer_idx][0]
n_row = 8
n_column = layer_activation.shape[-1]//n_row
f, ax = plt.subplots(n_row, n_column)
for i in range(n_row):
for j in range(n_column):
channel_image = layer_activation[:, :, i*n_column+j]
# image post-processing for better visualization
channel_image -= channel_image.mean()
channel_image /= channel_image.std()
channel_image *= 64
channel_image += 128
channel_image = np.clip(channel_image, 0, 255).astype('uint8')
ax[i, j].imshow(channel_image,)
ax[i, j].axis('off')
ax[i, j].set_xticklabels([])
ax[i, j].set_yticklabels([])
plt.subplots_adjust(wspace=0, hspace=0)
f.set_size_inches(n_column, n_row)
plt.show()
In [ ]:
for i in (1, 2, 3, 8, 10):
print(f'Feature_map with {i} convolution layer')
plot_activations(i, activations)
